// pages/pending/pending.js
Page({

    /**
     * 页面的初始数据
     */
    data: {
        pendingList: [], // 存储待审批申请列表数据
        loading: true,   // 控制加载状态显示
        pageTitle: '待审批申请',
        filter: 'pending' // 默认显示待审批的申请
    },

    /**
     * 生命周期函数--监听页面加载
     */
    onLoad(options) {
        console.log('页面加载，参数:', options);
        
        // 如果有filter参数，更新过滤条件
        if (options && options.filter) {
            console.log('检测到filter参数:', options.filter);
            this.setData({ 
                filter: options.filter,
                pageTitle: options.filter === 'approved' ? '已批准申请' : '待审批申请'
            });
        }
        
        console.log('准备获取申请列表，过滤条件:', this.data.filter);
        
        // 尝试修复用户角色问题
        this.fixUserRole();
        
        // 加载申请列表数据
        this.loadPendingApplications();
        
        // 添加调试信息
        this.diagnoseDatabase();
    },

    /**
     * 生命周期函数--监听页面初次渲染完成
     */
    onReady() {
        // 页面初次渲染完成后的处理逻辑
    },

    /**
     * 生命周期函数--监听页面显示
     */
    onShow() {
        console.log('页面显示，重新获取待审批申请列表');
        // 每次页面显示时刷新申请列表数据
        this.loadPendingApplications();
    },

    /**
     * 生命周期函数--监听页面隐藏
     */
    onHide() {
        // 页面隐藏时的处理逻辑
    },

    /**
     * 生命周期函数--监听页面卸载
     */
    onUnload() {
        // 页面卸载时的处理逻辑
    },

    /**
     * 页面相关事件处理函数--监听用户下拉动作
     */
    onPullDownRefresh() {
        console.log('下拉刷新，重新获取待审批申请列表');
        // 下拉刷新时重新加载申请列表
        this.loadPendingApplications();
    },

    /**
     * 页面上拉触底事件的处理函数
     */
    onReachBottom() {
        // 上拉触底加载更多数据的处理逻辑
    },

    /**
     * 用户点击右上角分享
     */
    onShareAppMessage() {
        // 分享页面时的处理逻辑
    },

    // 加载待审批的咨询申请
    loadPendingApplications: function() {
        const db = wx.cloud.database();
        const _ = db.command;
        const userInfo = wx.getStorageSync('userInfo');
        
        console.log('===== 开始获取申请 =====');
        console.log('当前用户信息:', userInfo);
        
        // 检查用户信息是否完整
        if (userInfo) {
            console.log('用户ID类型:', typeof userInfo._id);
            console.log('用户OpenID类型:', typeof (userInfo.openid || userInfo._openid || userInfo.openId));
            console.log('用户Role类型:', typeof userInfo.role);
            console.log('用户Role值:', userInfo.role);
        }
        
        console.log('过滤条件:', this.data.filter);
        
        // 检查用户权限，只有老师和管理员可以查看
        if (!userInfo || (userInfo.role !== 'teacher' && userInfo.role !== 'staff')) {
            console.log('权限检查失败: 用户不是老师或管理员，或未登录');
            console.log('用户信息为空?', !userInfo);
            console.log('用户角色是老师?', userInfo ? userInfo.role === 'teacher' : false);
            console.log('用户角色是管理员?', userInfo ? userInfo.role === 'staff' : false);
            console.log('userInfo.role类型:', userInfo ? typeof userInfo.role : 'N/A');
            
            if (userInfo && userInfo.role) {
                console.log('当前角色:', userInfo.role);
                console.log('角色值(编码):', encodeURIComponent(userInfo.role));
            }
            
            // 无权限时停止加载并返回上一页
            this.setData({ loading: false });
            
            wx.showToast({
                title: '您没有权限查看此页面',
                icon: 'none'
            });
            setTimeout(() => {
                wx.navigateBack();
            }, 1500);
            return;
        }
        
        console.log('权限检查通过: 用户角色=' + userInfo.role);
        this.setData({ loading: true });
        
        console.log('准备查询数据库: consultation_requests 集合');
        
        try {
            console.log('执行查询: status=' + this.data.filter);
            
            // 检查是否有过滤条件
            const query = {
                status: this.data.filter
            };
            console.log('查询条件:', JSON.stringify(query));
            
            // 执行数据库查询获取申请列表
            db.collection('consultation_requests')
                .where(query)
                .orderBy('createTime', 'desc')
                .get()
                .then(res => {
                    console.log('查询成功, 返回数据:', res);
                    console.log('返回数据类型:', typeof res.data);
                    console.log('返回数据长度:', res.data ? res.data.length : 0);
                    
                    // 检查是否有返回数据
                    if (!res.data || res.data.length === 0) {
                        console.log('未找到任何' + (this.data.filter === 'approved' ? '已批准' : '待审批') + '申请');
                        this.setData({
                            pendingList: [],
                            loading: false
                        });
                        wx.stopPullDownRefresh();
                        return;
                    }
                    
                    // 记录第一条数据的关键字段
                    const sample = res.data[0];
                    console.log('第一条数据示例:', sample);
                    console.log('- _id: ' + (sample._id || '未定义'));
                    console.log('- problemType: ' + (sample.problemType || '空'));
                    console.log('- description: ' + (sample.description || '空'));
                    console.log('- status: ' + (sample.status || '空'));
                    console.log('- createTime: ' + (sample.createTime ? (sample.createTime instanceof Date ? sample.createTime.toISOString() : JSON.stringify(sample.createTime)) : '空'));
                    console.log('- studentName: ' + (sample.studentName || '空'));
                    
                    // 格式化日期并规范显示内容
                    const formattedList = res.data.map((item, index) => {
                        console.log(`处理第${index + 1}条数据:`, item);
                        
                        // 格式化创建时间
                        if (item.createTime) {
                            let createTime;
                            try {
                                // 处理不同格式的时间数据
                                if (typeof item.createTime === 'string') {
                                    createTime = new Date(item.createTime);
                                } else if (item.createTime instanceof Date) {
                                    createTime = item.createTime;
                                } else if (item.createTime._serverDate) { // 处理云开发特有的服务器时间格式
                                    createTime = new Date(item.createTime._serverDate);
                                } else {
                                    // 处理服务器时间戳
                                    createTime = new Date(item.createTime.getTime ? item.createTime.getTime() : item.createTime);
                                }
                                
                                // 格式化为可读的时间字符串
                                const year = createTime.getFullYear();
                                const month = ('0' + (createTime.getMonth() + 1)).slice(-2);
                                const day = ('0' + createTime.getDate()).slice(-2);
                                const hours = ('0' + createTime.getHours()).slice(-2);
                                const minutes = ('0' + createTime.getMinutes()).slice(-2);
                                
                                item.createTimeFormatted = `${year}-${month}-${day} ${hours}:${minutes}`;
                                console.log(`第${index + 1}条数据时间格式化成功:`, item.createTimeFormatted);
                            } catch (timeErr) {
                                console.error(`第${index + 1}条数据时间格式化失败:`, timeErr);
                                item.createTimeFormatted = '时间格式错误';
                            }
                        }
                        
                        // 格式化预期咨询时间
                        if (item.expectedDate) {
                            item.expectedTimeFormatted = item.expectedDate;
                            if (item.expectedTimeSlot) {
                                item.expectedTimeFormatted += ' ' + item.expectedTimeSlot;
                            }
                        }
                        
                        return item;
                    });
                    
                    console.log('格式化后的数据列表:', formattedList);
                    
                    // 在设置数据前检查数据状态
                    console.log('更新前的pendingList:', this.data.pendingList);
                    console.log('即将设置的pendingList长度:', formattedList.length);
                    
                    // 更新页面数据并停止下拉刷新
                    this.setData({
                        pendingList: formattedList,
                        loading: false
                    }, () => {
                        // 检查更新后的数据状态
                        console.log('更新后的pendingList:', this.data.pendingList);
                        console.log('更新后的pendingList长度:', this.data.pendingList.length);
                    });
                    console.log('待审批申请列表已更新到页面');
                    wx.stopPullDownRefresh();
                })
                .catch(err => {
                    console.error('获取申请列表失败：', err);
                    
                    // 处理查询失败情况
                    wx.showToast({
                        title: '获取数据失败',
                        icon: 'none'
                    });
                    this.setData({ loading: false });
                    wx.stopPullDownRefresh();
                });
        } catch (error) {
            console.error('执行查询时出错:', error);
            this.setData({ loading: false });
            wx.showToast({
                title: '查询数据时发生错误',
                icon: 'none'
            });
            wx.stopPullDownRefresh();
        }
    },

    // 查看申请详情
    viewDetail: function(e) {
        const id = e.currentTarget.dataset.id;
        console.log('准备查看申请详情, ID:', id);
        
        // 如果是已批准的申请列表，则直接导航到结果填写页面
        if (this.data.filter === 'approved') {
            console.log('导航到结果填写页面, requestId:', id);
            wx.navigateTo({
                url: `/pages/result/result?requestId=${id}`,
            });
            return;
        }
        
        // 否则导航到详情页面
        wx.navigateTo({
            url: `/pages/detail/detail?id=${id}&from=pending`,
        });
    },
    
    // 诊断数据库问题
    diagnoseDatabase: function() {
        console.log('===== 数据库诊断开始 =====');
        const db = wx.cloud.database();
        
        // 检查用户信息
        const userInfo = wx.getStorageSync('userInfo');
        console.log('当前登录用户信息:', userInfo);
        if (userInfo) {
            console.log('用户ID:', userInfo._id);
            console.log('用户OpenID:', userInfo.openid || userInfo._openid || userInfo.openId);
            console.log('用户角色:', userInfo.role);
        } else {
            console.log('未检测到用户登录信息');
        }
        
        // 检查consultation_requests集合
        db.collection('consultation_requests').count().then(res => {
            console.log('consultation_requests集合总记录数:', res.total);
            
            // 查询所有状态的记录数
            return db.collection('consultation_requests').get();
        }).then(res => {
            console.log('获取到所有咨询申请记录:', res.data.length);
            console.log('所有申请详情:', res.data);
            
            // 检查pending状态的记录
            return db.collection('consultation_requests').where({
                status: 'pending'
            }).get();
        }).then(res => {
            console.log('获取到待审批申请记录数:', res.data.length);
            console.log('待审批申请详情:', res.data);
            
            // 检查approved状态的记录
            return db.collection('consultation_requests').where({
                status: 'approved'
            }).get();
        }).then(res => {
            console.log('获取到已批准申请记录数:', res.data.length);
            console.log('已批准申请详情:', res.data);
            
            console.log('===== 数据库诊断完成 =====');
        }).catch(err => {
            console.error('数据库诊断失败:', err);
        });
    },

    // 测试数据库连接
    testDatabase: function() {
        console.log('测试数据库连接');
        const db = wx.cloud.database();
        
        // 获取所有集合
        db.collection('consultation_requests').count().then(res => {
            console.log('数据库测试成功，consultation_requests集合总数:', res.total);
            wx.showToast({
                title: `共有${res.total}条记录`,
                icon: 'none'
            });
        }).catch(err => {
            console.error('数据库测试失败:', err);
            wx.showToast({
                title: '数据库连接测试失败',
                icon: 'none'
            });
        });
    },

    // 修复用户角色
    fixUserRole: function() {
        console.log('===== 检查用户角色 =====');
        
        // 获取本地存储的用户信息
        const userInfo = wx.getStorageSync('userInfo');
        console.log('当前存储的用户信息:', userInfo);
        
        if (!userInfo) {
            console.log('未找到用户信息，无法检查角色');
            return;
        }
        
        // 检查是否有角色字段
        if (!userInfo.role) {
            console.log('用户信息中没有角色字段，这是一个错误');
            wx.showToast({
                title: '用户角色信息缺失',
                icon: 'none'
            });
            setTimeout(() => {
                wx.navigateBack();
            }, 1500);
        } else {
            console.log('用户当前角色:', userInfo.role);
            // 不再修改用户角色，保留原始角色
        }
        
        // 记录当前角色信息用于调试
        console.log('当前用户角色:', userInfo.role);
    },

    // 自定义返回按钮处理函数
    goBack: function() {
        console.log('返回按钮被点击');
        wx.navigateBack({
            delta: 1
        });
    }
})